home *** CD-ROM | disk | FTP | other *** search
/ PCMania 44 / PCMania CD44_1.iso / pcmania / babel44 / goraudg.c < prev    next >
C/C++ Source or Header  |  1996-04-30  |  29KB  |  1,027 lines
  1. #include <pc.h>
  2. #include <process.h> 
  3. #include <stdlib.h>
  4. #include <stdio.h>
  5. #include <conio.h>
  6. #include <string.h>
  7. #include <math.h>
  8. #include <graphics.h>
  9.  
  10.  
  11. unsigned int searchtext(unsigned char *, unsigned char *,
  12.                         unsigned int, FILE *);
  13. unsigned int sigword(unsigned char *, unsigned int);
  14. unsigned int tomanombre(unsigned char *, unsigned char *, unsigned int);
  15. unsigned int tomanom_s(unsigned char *, unsigned char *, unsigned int);
  16. void cargar(FILE *);
  17. void initmatT(void);
  18. void scale(float, float, float);
  19. void rotate(float, float, float);
  20. void translate(float, float, float);
  21. void transform(void);
  22. void project(void);
  23. void dibujar(void);
  24. void matmul(float *, float *);
  25. void calnor(unsigned short);
  26. unsigned char colver(unsigned short, unsigned char);
  27. void borrap(void);
  28. void Bresen(unsigned short, unsigned short, unsigned short,
  29.             unsigned short, unsigned short);
  30. void interpolateY(unsigned short, unsigned char, unsigned short,
  31.               unsigned char, unsigned short);
  32. void interpolateX(unsigned short, unsigned short);
  33.  
  34. struct yuyu{
  35.  unsigned short npol;       /* num. absoluti de poligono (indice a caras[]) */
  36.  short prof;                /* profundidad de este */
  37. };
  38.  
  39. int comp(const struct yuyu *a, const struct yuyu *b); 
  40.  
  41.  
  42.  
  43. #define maxlon 40960
  44. unsigned char bufferR[maxlon]; /* buffer para datos de F. a leer */
  45. FILE *fichasc;              /* handle para fichero .asc a leer */
  46. unsigned int posr;          /* pos. relativa dentro del buffer */
  47. unsigned char string[50];   /* cadenas de trabajo */
  48. unsigned char string1[50];
  49. unsigned char nombref[30];
  50. unsigned char mam[30];
  51. unsigned char mam1[30];
  52. unsigned nvertices,nfaces;  /* num. de vertices y caras de objeto unico */
  53. float matT[4][4];           /* Matriz de transformación global */
  54. float mat[4][4];            /* matriz de trabajo */
  55. unsigned long nvert;        /* num. de vertices del objeto basico */
  56. unsigned long ntri;         /* num. de triangulos */
  57. unsigned long tri;          /* contador */
  58. float vertic[40000][3];     /* hay un max. de 40000 trian. tratables. 
  59.    La primera dim. es el num. de vertice y la segunda guarda la X, Y o Z */
  60. unsigned short caras[40000][3];
  61. struct yuyu caraZ[40000];   /* espacio para 40000 profundidades Z */
  62. double normca[40000][3];    /* espacio para almacenar las normales de 40000
  63.    caras */
  64. /* reservamos espacio para calcular las coords. finales de cada vert. */
  65. float vtra[40000][3];
  66. /* y tambien el corresp. espacio para las coords. de pantalla */
  67. short vpant[40000][2];
  68. /* en cavert[] se guarda, por cada vertice, la lista de caras en las que
  69.    interviene. (Para saber con rapidez los poligonos cuyas normales tienen
  70.    que promediarse para hallar el color de cada vertice). icaver[] tiene
  71.    los indices a cavert[] de cada vertice */
  72. unsigned short cavert[40000*4];   
  73. unsigned short icaver[40000];
  74. unsigned short pcavert;     /* indice al primer registro cavert[] libre */
  75.  
  76. int nobj;       /* num. de objeto en curso */
  77. float xMen;
  78. float xMay;
  79. float yMen;
  80. float yMay;
  81. float zMen;
  82. float zMay;                 /* coords. maximas XYZ del objeto */
  83. float trab;
  84. float radgra;               /* para la conver. de grados a rad. */
  85. double xluz,yluz,zluz;      /* posicion de la fuente de luz */
  86. double var1,var2,var3;      /* valores interm. para calc. de vector unidad */
  87. double xluni,yluni,zluni;   /* el vector unidad de la fuente de luz */
  88. unsigned char palet;        /* flag. para indicar la micropaleta en curso */
  89. unsigned short tfil[1200];  /* tabla temporal para limites X de llenado del
  90.                                poligono en curso */
  91. unsigned char tfilc[1200];  /* tabla temporal para colores Goraud de aristas
  92.                                de triangulo en curso. (Luego el interior se
  93.                                llena por interpolación) */
  94.  
  95. main()
  96. {
  97. unsigned int a,b,c,d,e;
  98.  
  99. float xang,yang,zang;       /* angulos de rotación */
  100. float xinc,yinc,zinc;       /* incrementos para las rotat. */
  101. float ix,iy,iz;             /* para la traslación */
  102. float sx,sy,sz;             /* escala */
  103. unsigned short v;
  104. unsigned char string[50];   /* cadenas de trabajo */
  105. unsigned char mam[30];
  106. char tecla;
  107. float increm;
  108. float col;
  109. unsigned char oboluz;       /* si=0, las ords. de mov. afectan a los obj.
  110.                                si no, afectan a la pos. del punto de luz */
  111.  
  112. oboluz=0;
  113. xMen=0;                                      
  114. yMen=0;
  115. zMen=0;
  116. xMay=0;
  117. yMay=0;
  118. zMay=0;                     /* hay que conocer los extremos del ob. */
  119. ntri=0;
  120. radgra=.01744;
  121. posr=0;
  122.  
  123. puts("                    Solid 0.91 por Jose Manuel Muñoz Perez\n");
  124. system("dir /w *.asc");
  125. printf("indica el fichero (ASC) de 3d Studio a tratar ");
  126. scanf("%s",mam);
  127. strcpy(string,mam);
  128. strcat(string,".asc");
  129. if ((fichasc=fopen(string,"r"))==0)
  130.  {
  131.  printf("\n Error: El fichero no puede abrirse!\n\n");
  132.  exit(1);
  133.  }
  134. cargar(fichasc);            /* cargar 70 lineas del f. */
  135. posr=0;
  136. posr=searchtext(bufferR,"Named object:",posr,fichasc);
  137.  
  138. while (posr!=65535)
  139.  {
  140. /* buscar objeto */
  141.  posr=sigword(bufferR,posr);/* nos posicionamos sobre el nombre del objeto */
  142.  posr++;                    /* nos saltamos las comillas del nombre */
  143.  posr=tomanombre(bufferR,mam,posr); 
  144. /* metemos el nombre del objeto en 'mam' */
  145.  a=strlen(mam);
  146.  mam[a-1]=0;                /* quitamos las comillas del nombre poniendo
  147.     un 0 (fin de cadena, ¿recuerdan?) */
  148.  posr=sigword(bufferR,posr);/* nos posicionamos sobre la siguiente palabra
  149.     (el tipo de objeto; Camera, Direct light, Tri-mesh (objeto)) */
  150.  posr=tomanom_s(bufferR,mam1,posr);
  151.  
  152.  printf("leyendo objeto ");
  153.  printf("%s\n",mam);
  154. /* ya tenemos el tipo de objeto en mam1[] */
  155.  if (!strcmp(mam1,"Camera"))
  156.   {                         /* la camara no nos interesa aqui */
  157.   posr=searchtext(bufferR,"Named object:",posr,fichasc);
  158.   continue;
  159.   }
  160.  
  161.  else if (!strcmp(mam1,"Direct"))
  162.   {                         /* por "Direct light" */
  163.   posr=searchtext(bufferR,"Position:",posr,fichasc);
  164.   posr=searchtext(bufferR,"X:",posr,fichasc);
  165.   xluz=atof(bufferR+posr);
  166.   posr=searchtext(bufferR,"Y:",posr,fichasc);
  167.   zluz=atof(bufferR+posr);
  168.   posr=searchtext(bufferR,"Z:",posr,fichasc);
  169.   yluz=atof(bufferR+posr);
  170.   posr=searchtext(bufferR,"Named object:",posr,fichasc);
  171. /* recordemos que hay que invertir Y y Z */
  172.   continue;
  173.   }
  174.  
  175.  else if (!strcmp(mam1,"Tri-mesh,"))
  176.   {
  177.   posr=searchtext(bufferR,"Vertices:",posr,fichasc);
  178.   posr++;                   /* saltar espacio en blanco */
  179.   nvertices=atoi(bufferR+posr);
  180.   posr=searchtext(bufferR,"Faces:",posr,fichasc);
  181.   posr++;                   /* saltar espacio en blanco */
  182.   nfaces=atoi(bufferR+posr);
  183. /* ahora tomar los vertices. Primero nos situamos en el primero -el 0 */
  184.   posr=searchtext(bufferR,"Vertex 0:",posr,fichasc);
  185.  
  186.   for (a=0;a<nvertices;a++)
  187.    {
  188.    posr=searchtext(bufferR,"X:",posr,fichasc);
  189.    vertic[a][0]=atof(bufferR+posr);
  190. /* ahora recordemos que 3D Studio invierte Y y Z con respecto al sistema 
  191.    "izquierdo" que empleamos nosotros */
  192.    posr=searchtext(bufferR,"Y:",posr,fichasc);
  193. /* el *(-1) es para que los modelos queden "de frente" */
  194.    vertic[a][2]=(atof(bufferR+posr))*(-1);
  195.    posr=searchtext(bufferR,"Z:",posr,fichasc);
  196.    vertic[a][1]=atof(bufferR+posr);
  197.    if (vertic[a][0]<xMen)
  198.     xMen=vertic[a][0];
  199.    if (vertic[a][1]<yMen)
  200.     yMen=vertic[a][1];
  201.    if (vertic[a][2]<zMen)
  202.     zMen=vertic[a][2];
  203.    if (vertic[a][0]>xMay)
  204.     xMay=vertic[a][0];
  205.    if (vertic[a][1]>yMay)
  206.     yMay=vertic[a][1];
  207.    if (vertic[a][2]>zMay)
  208.     zMay=vertic[a][2];
  209.    } 
  210. /* ahora tomaremos los datos de la lista de caras */
  211.   posr=searchtext(bufferR,"Face list:",posr,fichasc);
  212.   for (a=0;a<nfaces;a++)
  213.    {
  214.    posr=searchtext(bufferR,"Face ",posr,fichasc);
  215.    posr=searchtext(bufferR," A:",posr,fichasc); 
  216.    caras[a][0]=atoi(bufferR+posr);      /* tomar 1er vertice del trian. */
  217.    posr=searchtext(bufferR," B:",posr,fichasc); 
  218.    caras[a][1]=atoi(bufferR+posr);      /* tomar 2ndo vertice del trian. */
  219.    posr=searchtext(bufferR," C:",posr,fichasc); 
  220.    caras[a][2]=atoi(bufferR+posr);      /* tomar 3er vertice del trian. */
  221.    }
  222. /* mirar si hay mas objetos */
  223.   posr=searchtext(bufferR,"Named object:",posr,fichasc);
  224.   }
  225.  }
  226.  
  227. /* Se acabo la lectura */
  228. fclose(fichasc);
  229. /* YA LO HEMOS LEIDO TODO */
  230. /* ahora, antes de visualizar, construimos tablas cavert[] e icaver[] */
  231. puts("Construyendo registros con caras donde aparece cada vertice (paciencia)");
  232. pcavert=0;
  233. for (a=0,c=0;a<nvertices;a++)
  234.  {
  235.  icaver[c]=pcavert;
  236.  c++;
  237.  for (b=0;b<nfaces;b++)
  238.   {
  239.   if (a==caras[b][0] || a==caras[b][1] || a==caras[b][2])
  240.    {
  241.    cavert[pcavert]=b;
  242.    pcavert++;
  243.    }
  244.   }
  245.  }
  246. icaver[c]=pcavert;
  247. xang=0; yang=0; zang=0;
  248. xinc=0; yinc=0; zinc=0;
  249. sx=1; sy=1; sz=1;
  250. ix=0; iy=0;
  251.  
  252. trab=xMay+fabs(xMen);
  253.  
  254. if (trab<yMay+fabs(yMen))
  255.  trab=yMay+fabs(yMen);
  256. if (trab<zMay+fabs(zMen))
  257.  trab=zMay+fabs(zMen);
  258. if (xMay>+fabs(xMen))
  259.  ix=((xMay-fabs(xMen))/2)*(-1);
  260. else
  261.  ix=(fabs(xMen)-xMay)/2;
  262. if (yMay>+fabs(yMen))
  263.  iy=((yMay-fabs(yMen))/2)*(-1);
  264. else
  265.  iy=(fabs(yMen)-yMay)/2;
  266. if (zMay>+fabs(zMen))
  267.  iz=((zMay-fabs(zMen))/2)*(-1);
  268. else
  269.  iz=(fabs(zMen)-zMay)/2;
  270.  
  271. iz+=(trab*4)*(-1);
  272. zluz-=(trab*4)*(-1);
  273. increm=trab/3;
  274. GrSetMode(GR_default_graphics);
  275. /* creamos dos paleta de 128 tonos de color para los sombreados a partir
  276.    de la posición 0 de la paleta global de 256 tonos */
  277. for (col=0,v=0;v<128;v++)
  278.  {
  279. /* paleta "roja" */ 
  280.  col+=1.5;
  281.  GrSetColor(v,col,0,0);
  282.  }
  283. for (col=0,v=0;v<128;v++)
  284.  {
  285. /* paleta "blanca" */
  286.  col+=1.5;
  287.  GrSetColor(v+128,col,col,col);
  288.  }
  289. palet=1;                    /* empezar apuntando a la paleta roja */
  290. tecla=0;
  291. while (tecla!=27) 
  292.  {                          /* rotar mientras no se pulse una tecla */
  293.  initmatT();                /* inicializar matriz global */
  294.  scale(sx,sy,sz);
  295.  xang+=xinc;
  296.  yang+=yinc;
  297.  zang+=zinc;
  298.  rotate(xang,yang,zang);
  299.  translate(ix,iy,iz);
  300. /* sigue el borrado de pantalla */
  301.  borrap();
  302.  transform();
  303.  project();             
  304. /* ahora hallar el vector unidad de la fuente de luz */
  305.  var1=(xluz*xluz) + (yluz*yluz) + (zluz*zluz);
  306.  var2=sqrt(var1);
  307.  if (var2==0)
  308.   var2=0.001;
  309.  var3=1/var2;
  310.  xluni=xluz*var3;
  311.  yluni=yluz*var3;
  312.  zluni=zluz*var3;
  313.  dibujar(); 
  314.  xinc=0; yinc=0; zinc=0;    /* resetear increms. de angulos */
  315. aagh:
  316.  tecla=getkey();
  317.  switch(tecla)
  318.   {
  319. /* con la tecla i se intercambia el funcionamiento de las teclas para los
  320.    modelos o las fuentes de luz */
  321.   case 'i':                 
  322.    if (oboluz==0)
  323.     oboluz=1;
  324.    else
  325.     oboluz=0;
  326.    break;  
  327.   case 'c':                 /* cambiar el color del objeto */
  328.    if (palet<2)
  329.     palet++;
  330.    else
  331.     palet=1;
  332.    break;  
  333.   case 'g':                 /* hacer mas pequeños los desplazamientos */
  334.    increm/=2;
  335.    break;
  336.   case 'h':                 /* hacer mas grandes los desplazamientos */
  337.    increm*=2;
  338.    break; 
  339.   case 'n':
  340.    if (oboluz==0)
  341.     iz+=increm;             /* acercar objeto o fuente */
  342.    else
  343.     zluz+=increm;            
  344.    break;
  345.   case 'm':
  346.    if (oboluz==0)
  347.     iz-=increm;             /* alejar */
  348.    else
  349.     zluz-=increm;             
  350.    break;
  351.   case 'q':                         
  352.    if (oboluz==0)
  353.     iy+=increm;             /* arriba */
  354.    else
  355.     yluz+=increm;
  356.    break;
  357.   case 'a':
  358.    if (oboluz==0)
  359.     iy-=increm;             /* abajo */
  360.    else
  361.     yluz-=increm;
  362.    break;
  363.   case 'o':
  364.    if (oboluz==0)
  365.     ix-=increm;             /* izquierda */
  366.    else
  367.     xluz-=increm;
  368.    break;
  369.   case 'p':
  370.    if (oboluz==0)
  371.     ix+=increm;             /* derecha */
  372.    else
  373.     xluz+=increm;
  374.    break;
  375.   case '1':
  376.    xinc=10*radgra;          /* casos de rotaciones */
  377.    break;
  378.   case '2': 
  379.    xinc=-10*radgra;
  380.    break;
  381.   case '3':
  382.    yinc=10*radgra;
  383.    break;
  384.   case '4': 
  385.    yinc=-10*radgra;
  386.    break;
  387.   case '5':
  388.    zinc=10*radgra;
  389.    break;
  390.   case '6': 
  391.    zinc=-10*radgra;
  392.    break;
  393.   case 27:
  394.    exit(0);                 /* se acabo */
  395.   default :
  396.    goto aagh;               /* ¡horror! ¡un goto! */
  397.   }
  398.  }
  399. getkey();
  400. }
  401.  
  402.  
  403. /* Esta funcion busca una cadena de texto dentro de un array de caracteres.
  404.    Devuelve 65535 si no lo ha hallado o un valor entero indicando su pos.
  405.    en dicho array. La funcion acepta como parametros un puntero a la cadena
  406.    donde va a efectuarse la busqueda, otro puntero a la cadena que se va a
  407.    buscar y un indice al punto de principio para la busqueda (puede ser
  408.    preciso que la investigacion no comienze desde el principio).
  409.    Cuando una ocurrencia sobrepase las ultimas lineas de la carga anterior
  410.    se leera otra tanda de lineas (por ello tambien adjuntamos el puntero
  411.    *FILE al fichero que deseamos leer). logicamente en ese caso el indice
  412.    a devolver continuara la busqueda desde 0 */
  413. unsigned int searchtext(unsigned char *buffer, unsigned char *text,
  414.                         unsigned int desp, FILE *fich)
  415. {
  416. long a,b,c;
  417. unsigned char loncad;
  418. int d;
  419.  
  420.  a=0;                   
  421.  loncad=strlen(text);
  422. sigcar:
  423.  while(buffer[desp]!=text[a] && buffer[desp]!=255 && buffer[desp]!=0)
  424.   desp++;
  425.  
  426.  if (buffer[desp]==255)
  427.   {
  428.   cargar(fich);             /* leer mas lineas */    
  429.   desp=0;
  430.   goto sigcar;
  431.   }   
  432.  if (buffer[desp]==0)
  433.   return(65535);            /* marca de que no se ha hallado correspondencia */ 
  434. /* si llega aqui, es que se ha leido el car. */
  435.  d=desp;
  436.  for (b=0,c=desp;b<loncad-1;a++,b++,c++)
  437.   {
  438.   if (buffer[c]!=text[a])
  439.    {
  440.    a=0;
  441.    desp++; 
  442.    goto sigcar;
  443.    }
  444.   }
  445.  a=d+loncad;
  446.  return (a);
  447. /* a=d+loncad es porque el indice devuelto corresponde a la primera pos.
  448.    del array, despues de la ocurrencia hallada */ 
  449. }
  450.  
  451.  
  452. /* llamamos a sigword() cuando deseamos hallar el indice dentro del array
  453.    a la sig. palabra que sigue a la ultima procesada (indicada por desp) */
  454. unsigned int sigword(unsigned char *buffer, unsigned int desp)
  455. {
  456. /* primero nos saltamos los car. de la palabra actual */
  457. while(buffer[desp]!=32 && buffer[desp]!=13 &&
  458.       buffer[desp]!=10 && buffer[desp]!=255)
  459.  desp++;
  460. if (bufferR[desp]==255)
  461.  {                          /* ultima linea de carga anterior */
  462.  cargar(fichasc);           /* leer otra tanda de lineas */
  463.  desp=0;
  464.  }
  465. /* y ahora los espacios hasta la siguiente palabra */
  466. while((buffer[desp]==32 || buffer[desp]==13 || buffer[desp]==10) &&
  467.        buffer[desp]!=255)
  468.  desp++;
  469. if (bufferR[desp]==255)
  470.  {                          
  471.  cargar(fichasc);           
  472.  desp=0;
  473.  }
  474. return desp;
  475. }
  476.  
  477.  
  478. /* toma el nombre alterando algunos caracteres que no permite el POV */
  479. unsigned int tomanombre(unsigned char *buffer, 
  480.                         unsigned char *text, unsigned int desp)
  481. {
  482. unsigned char a;
  483.  
  484. a=0;
  485. while(buffer[desp]!=32 && buffer[desp]!=13 && buffer[desp]!=10)
  486.  {
  487.  if ((buffer[desp]>=48 && buffer[desp]<=57) || buffer[desp]=='"' ||
  488.      (buffer[desp]>=65 && buffer[desp]<=90) ||
  489.      (buffer[desp]>=97 && buffer[desp]<=122))
  490.   text[a]=buffer[desp];     /* es uno de los car. permitidos por POV */
  491.  else
  492.   text[a]='_';
  493.  a++;
  494.  desp++;
  495.  }
  496. text[a]=0;                  /* marca para fin de cadena */
  497. return desp;
  498. }
  499.  
  500.  
  501. /* toma el nombre sin alteraciones */
  502. unsigned int tomanom_s(unsigned char *buffer,
  503.                        unsigned char *text, unsigned int desp)
  504. {
  505. unsigned char a;
  506.  
  507. a=0;
  508. while(buffer[desp]!=32 && buffer[desp]!=13 && buffer[desp]!=10)
  509.  {
  510.  text[a]=buffer[desp];
  511.  a++;
  512.  desp++;
  513.  }
  514. text[a]=0;                  /* marca para fin de cadena */
  515. return desp;
  516. }
  517.  
  518.  
  519. /* ahora leer 80 lineas como maximo a partir de bufferR+0 */
  520. void cargar(FILE *fich)
  521. {
  522. unsigned int a,b,c;
  523.  
  524. for (a=0,b=80;b!=0;b--)
  525.  {
  526.  if (!feof(fich))
  527.   {
  528.   fgets(bufferR+a,512,fich);
  529.   for (c=a;c<a+512;c++)
  530.    {
  531.    if (bufferR[c]==0)
  532.     break;
  533.    }
  534.   a=c;  
  535.   }
  536.  else
  537.   {
  538.   bufferR[c]=0;             /* marca de final de fichero */
  539.   return;
  540.   }
  541.  }
  542. bufferR[c]=255;             /* marca de ultima de las 80 lineas */
  543. }   
  544.  
  545.  
  546.  
  547. /* EMPIEZAN LAS FUNCIONES 3D PROPIAMENTE DICHAS */
  548.  
  549. /* Incializa la matriz de transformación global */
  550. void initmatT(void)
  551. {
  552. matT[0][0]=1; matT[0][1]=0; matT[0][2]=0; matT[0][3]=0;
  553. matT[1][0]=0; matT[1][1]=1; matT[1][2]=0; matT[1][3]=0;
  554. matT[2][0]=0; matT[2][1]=0; matT[2][2]=1; matT[2][3]=0;
  555. matT[3][0]=0; matT[3][1]=0; matT[3][2]=0; matT[3][3]=1;
  556. }
  557.  
  558.  
  559. /* crea la matriz de escalación y la multiplica por la global */
  560. void scale(float sX, float sY, float sZ)
  561. {
  562.  
  563. /* inicialización de la matriz de trabajo para escalar */
  564. mat[0][0]=sX; mat[0][1]=0;  mat[0][2]=0;  mat[0][3]=0;
  565. mat[1][0]=0;  mat[1][1]=sY; mat[1][2]=0;  mat[1][3]=0;
  566. mat[2][0]=0;  mat[2][1]=0;  mat[2][2]=sZ; mat[2][3]=0;
  567. mat[3][0]=0;  mat[3][1]=0;  mat[3][2]=0;  mat[3][3]=1;
  568.  
  569. /* Concatenación con la matriz maestra, el result. queda en matT */
  570. matmul(mat,matT);
  571. }
  572.  
  573.  
  574. /* crea las matrices de rotación para cada eje y las va concatenando con
  575.    la matriz de transformación global */
  576. void rotate(float aX,float aY,float aZ)
  577. {
  578.  
  579. if (aX!=0)
  580.  {
  581. /* Inicializar rotación en X */
  582.  
  583.  mat[0][0]=1; mat[0][1]=0;        mat[0][2]=0;       mat[0][3]=0;
  584.  mat[1][0]=0; mat[1][1]=cos(aX);  mat[1][2]=sin(aX); mat[1][3]=0;
  585.  mat[2][0]=0; mat[2][1]=-sin(aX); mat[2][2]=cos(aX); mat[2][3]=0;
  586.  mat[3][0]=0; mat[3][1]=0;        mat[3][2]=0;       mat[3][3]=1;
  587.  
  588. /* concatenarla con la maestra */
  589.  matmul(mat,matT);
  590.  }
  591.  
  592. if (aY!=0)
  593.  {
  594. /* Inicializar rotación en Y */
  595.  
  596.  mat[0][0]=cos(aY); mat[0][1]=0; mat[0][2]=-sin(aY); mat[0][3]=0;
  597.  mat[1][0]=0;       mat[1][1]=1; mat[1][2]=0;        mat[1][3]=0;
  598.  mat[2][0]=sin(aY); mat[2][1]=0; mat[2][2]=cos(aY);  mat[2][3]=0;
  599.  mat[3][0]=0;       mat[3][1]=0; mat[3][2]=0;        mat[3][3]=1;
  600.  
  601. /* concatenarla con la maestra */
  602.  matmul(mat,matT);
  603.  }
  604.  
  605. if (aZ!=0)
  606.  {
  607. /* Inicializar rotación en Z */
  608.  
  609.  mat[0][0]=cos(aZ);  mat[0][1]=sin(aZ); mat[0][2]=0; mat[0][3]=0;
  610.  mat[1][0]=-sin(aZ); mat[1][1]=cos(aZ); mat[1][2]=0; mat[1][3]=0;
  611.  mat[2][0]=0;        mat[2][1]=0;       mat[2][2]=1; mat[2][3]=0;
  612.  mat[3][0]=0;        mat[3][1]=0;       mat[3][2]=0; mat[3][3]=1;
  613. /* concatenarla con la maestra */
  614.  matmul(mat,matT);
  615.  }
  616. }
  617.  
  618.  
  619. /* crea la matriz de traslación y la multiplica por la global. Con esta
  620.    matriz trasladaremos al objeto desde su pos. inicial en el centro del
  621.    universo a las coords. de vision una distancia tX, tY y tZ */
  622. void translate(float tX, float tY, float tZ)
  623. {
  624.  
  625. mat[0][0]=1;  mat[0][1]=0;  mat[0][2]=0;  mat[0][3]=0;
  626. mat[1][0]=0;  mat[1][1]=1;  mat[1][2]=0;  mat[1][3]=0;
  627. mat[2][0]=0;  mat[2][1]=0;  mat[2][2]=1;  mat[2][3]=0;
  628. mat[3][0]=tX; mat[3][1]=tY; mat[3][2]=tZ; mat[3][3]=1;
  629.  
  630. /* Concatenacion con la matriz de transform. global */
  631. matmul(matT,mat);
  632. }
  633.  
  634.  
  635. void matmul(float *mat1, float *mat2)
  636. {
  637. unsigned char i,j,k;
  638. float matra[4][4];          /* Matriz temporal */
  639.  
  640. /* y ahora realizamos la multiplicación propiamente dicha */
  641. for (i=0; i<4; i++)
  642.  for (j=0; j<4; j++)
  643.   {
  644.   matra[i][j]=0;
  645.   for (k=0; k<4; k++)
  646.    matra[i][j]+=(*(mat1+(i*4)+k)) * (*(mat2+(k*4)+j));
  647.   }                         
  648.  
  649. /* el resultado acaba siempre en la matriz de transformacion */
  650. for (i=0; i<4; i++)
  651.  for (j=0; j<4; j++)
  652.   matT[i][j]=matra[i][j];
  653.  
  654. }
  655.  
  656.  
  657. /* multiplicamos todos los vertices del cubo por la matriz de transformación
  658.    global para obtener las coordenadas visuales del objeto */
  659. void transform(void)
  660. {
  661. unsigned short v;
  662. float x,y,z;
  663.  
  664. for (v=0; v<nvertices; v++)
  665.  {
  666.  x=vertic[v][0]; 
  667.  y=vertic[v][1]; 
  668.  z=vertic[v][2];
  669. /* calcular vertices "transformados a su pos. final en el espacio */
  670.  vtra[v][0]=x*matT[0][0] + y*matT[1][0] + z*matT[2][0] + matT[3][0];
  671.  vtra[v][1]=x*matT[0][1] + y*matT[1][1] + z*matT[2][1] + matT[3][1];
  672.  vtra[v][2]=x*matT[0][2] + y*matT[1][2] + z*matT[2][2] + matT[3][2];
  673.  }
  674. }
  675.  
  676.  
  677. /* ahora proyectamos las coordenadas visuales halladas (vcubos[]) en la
  678.    pantalla aplicando esta función para la perspectiva */
  679. void project(void)
  680. {
  681. unsigned short p,v;
  682. int distancia;
  683.  
  684. for (p=0,v=0,distancia=1000; v<nvertices; v++)
  685.  {
  686.  vpant[v][0]=(distancia*vtra[v][0]/vtra[v][2])*(-1);
  687.  vpant[v][1]=distancia*vtra[v][1]/vtra[v][2];
  688.  }
  689. }
  690.  
  691.  
  692. /* Dibujar la forma */
  693. void dibujar(void)
  694. {
  695. unsigned short a,b,c,d,e,f,g;
  696. long vi;
  697. float x1,y1,z1, x2,y2,z2, x3,y3,z3, zm;
  698. short h,i,j;
  699. double col;
  700. unsigned char color;
  701. unsigned short coord[12];   /* 2 veces las coords. de pantalla de 3 vert. */
  702. unsigned char colv[7];      /* 2 veces los colores de tres vert. */
  703.  
  704. for (a=0,b=0; a<nfaces; a++)
  705.  {
  706.  x1=vtra[caras[a][0]][0];
  707.  x2=vtra[caras[a][1]][0];
  708.  x3=vtra[caras[a][2]][0];
  709.  
  710.  y1=vtra[caras[a][0]][1];
  711.  y2=vtra[caras[a][1]][1];
  712.  y3=vtra[caras[a][2]][1];
  713.  
  714.  z1=vtra[caras[a][0]][2];
  715.  z2=vtra[caras[a][1]][2];
  716.  z3=vtra[caras[a][2]][2];
  717.  
  718.  vi=(x3*((z1*y2)-(y1*z2))) + (y3*((x1*z2)-(z1*x2))) + (z3*((y1*x2)-(x1*y2)));
  719.  if (vi<0)
  720.   continue; 
  721.  zm=z1+z2+z3/3;             /* Z promediada de los tres vertices */
  722.  caraZ[b].prof=zm;          /* profundidad media */
  723.  caraZ[b].npol=a;           /* num. absoluto del poligono */
  724. /* calcular y guardar la normal del poligono visible */
  725.  calnor(a);                 /* calcula la normal del pol. */
  726.  b++;
  727.  }
  728.  
  729. /* seguidamente clasificamos las profundidades usando qsort() */
  730. /* qsort(caraZ,b,4,(unsigned short(*)(const short *,const short *)) comp);*/
  731. qsort(caraZ,b,4, comp);
  732.  
  733. for (a=0;a<b;a++)
  734.  {
  735. /* Seguidamente se calcula el color de cada vertice del poligono visible en
  736.    curso */
  737.  c=caraZ[a].npol;           /* num. absoluto del poligono */
  738.  for (d=0;d<3;d++)
  739.   {                         /* mirar tres vertices */
  740.   e=caras[c][d];            /* numero absoluto del vertice */
  741.   f=icaver[e];              /* indice a registro de caras de este vertice */
  742.   for (var1=0,var2=0,var3=0,g=0;g<icaver[e+1]-icaver[e];g++)
  743.    {
  744. /* sumamos las normales de las caras en las que interviene el vert. */
  745.    var1+=normca[cavert[f+g]][0];
  746.    var2+=normca[cavert[f+g]][1];
  747.    var3+=normca[cavert[f+g]][2];
  748.    }
  749.   var1/=(icaver[e+1]-icaver[e]);
  750.   var2/=(icaver[e+1]-icaver[e]);
  751.   var3/=(icaver[e+1]-icaver[e]);
  752. /* ya tenemos la normal promediada para el vertice */
  753. /* ahora obtendremos el valor de 0 a 1 que indica el grado de iluminación */
  754.   col=(var1*xluni)+(var2*yluni)+(var3*zluni);
  755. /* El angulo entre la normal del triangulo y el vector de la fuente de luz
  756.    es la relación entre el coseno del angulo y el producto escalar de los
  757.    vectores. El rayo de luz es perpendicular a la superficie -maxima luz-
  758.    cuando el coseno=1 y es paralelo al poligono -minima ilum.- cuando es =0.
  759.    Si el coseno es negativo, el triangulo tomara el valor minimo de luz (o
  760.    sea el de la iluminación ambiental que hayamos marcado) ya que la fuente
  761.    de luz no incide sobre el poligono (esta "detras") */
  762.   if (col<0)
  763.    col=0;
  764.   else 
  765.    col*=128;
  766.   color=abs(col)+(palet*128);
  767.   colv[d]=color;
  768.   }
  769. /* ahora efectuamos LA RASTERIZACION. 
  770.    Primero tomar las coords. de pantalla de los tres vertices */
  771.  coord[0]=vpant[caras[c][0]][0]+320;
  772.  coord[1]=vpant[caras[c][0]][1]+240;
  773.  coord[2]=vpant[caras[c][1]][0]+320;
  774.  coord[3]=vpant[caras[c][1]][1]+240;
  775.  coord[4]=vpant[caras[c][2]][0]+320;
  776.  coord[5]=vpant[caras[c][2]][1]+240;
  777. /* lo que sigue se hace por comodidad */
  778.  coord[6]=coord[0];
  779.  coord[7]=coord[1];
  780.  coord[8]=coord[2];
  781.  coord[9]=coord[3];
  782.  coord[10]=coord[4];
  783.  coord[11]=coord[5];
  784.  colv[3]=colv[0];
  785.  colv[4]=colv[1];
  786.  colv[5]=colv[2];
  787.  colv[6]=colv[0];
  788. /* hallar el vertice superior izquierdo */
  789.  for (e=0,d=481;e<5;e+=2)
  790.   {
  791.   if (coord[e+1]<d)
  792.    {
  793.    d=coord[e+1];
  794.    f=e>>1;
  795.    }
  796.   else if (coord[e+1]==d)
  797.    {
  798.    if (coord[e]>coord[f<<2])
  799.     continue;
  800.    else
  801.     f=e>>1;
  802.    } 
  803.   }
  804. /* ya tenemos en 'f' el num. de vertice superior izquierdo */  
  805.  g=f;
  806.  f=f<<1;
  807.  Bresen(coord[f],coord[f+1],coord[f+2],coord[f+3],0);
  808. /* calc. color de cada punto de la linea */
  809.  interpolateY(coord[f+1],colv[g],coord[f+3],colv[g+1],0);
  810.  if (coord[f+3]<coord[f+5])
  811.   {
  812.   Bresen(coord[f+2],coord[f+3],coord[f+4],coord[f+5],0);
  813.   interpolateY(coord[f+3],colv[g+1],coord[f+5],colv[g+2],0);
  814.   d=f+5;
  815.   }
  816.  else
  817.   {
  818.   Bresen(coord[f+2],coord[f+3],coord[f+4],coord[f+5],480);
  819.   interpolateY(coord[f+3],colv[g+1],coord[f+5],colv[g+2],480);
  820.   d=f+3;
  821.   }
  822.  if (coord[f+5]!=coord[f+7])
  823.   {
  824.   Bresen(coord[f+4],coord[f+5],coord[f+6],coord[f+7],480);
  825.   interpolateY(coord[f+5],colv[g+2],coord[f+7],colv[g+3],480);
  826.   }
  827. /* fill procede a interpolar los colores entre ambas bandas Y */
  828.  interpolateX(coord[f+1],coord[d]);
  829.  }
  830.  
  831. }
  832.  
  833.  
  834. int comp(const struct yuyu *a, const struct yuyu *b)
  835.  {
  836.  return (a->prof)-(b->prof); 
  837.  }
  838.  
  839.  
  840. /* hallar la normal del poligono 'np' */
  841. void calnor(unsigned short np)
  842. {
  843. double xi,yi,zi,xf,yf,zf;   /* valores intermedios para calculo de normales */
  844. double xnor,ynor,znor;      /* normal del poligono */
  845. double xuni,yuni,zuni;      /* la normal convertida a vector unidad */
  846.  
  847. /* calcular vector de vertice 0 al 1 */
  848. xi=vtra[caras[np][1]][0] - vtra[caras[np][0]][0];
  849. yi=vtra[caras[np][1]][1] - vtra[caras[np][0]][1];
  850. zi=vtra[caras[np][1]][2] - vtra[caras[np][0]][2];
  851.  
  852. /* calcular vector de vertice 0 al 2 */
  853. xf=vtra[caras[np][2]][0] - vtra[caras[np][0]][0];
  854. yf=vtra[caras[np][2]][1] - vtra[caras[np][0]][1];
  855. zf=vtra[caras[np][2]][2] - vtra[caras[np][0]][2];
  856.  
  857. /* normal del poligono */
  858. xnor= (yi*zf) - (zi*yf);    /* X */
  859. ynor= (zi*xf) - (xi*zf);    /* Y */
  860. znor= (xi*yf) - (yi*xf);    /* Z */
  861.  
  862. var1=(xnor*xnor) + (ynor*ynor) + (znor*znor);
  863. var2=sqrt(var1);
  864. if (var2==0)
  865.  var2=0.001;
  866. var3=1/var2;
  867.   
  868. xuni= var3*xnor;            /* vector unidad de la normal del poligono */
  869. yuni= var3*ynor;
  870. zuni= var3*znor;
  871. /* almacenamos el vector unidad del poligono */
  872. normca[np][0]=xuni;
  873. normca[np][1]=yuni;
  874. normca[np][2]=zuni;
  875. }
  876.  
  877.  
  878. /* borrado de pantalla */
  879. void borrap(void)
  880. {
  881. unsigned char *p;
  882. unsigned long a;
  883.  
  884. p=0xD0000000;
  885. for (a=0;a<307200;a++,p++)
  886.  *p=0;
  887. }
  888.  
  889.  
  890. /* algoritmo de brasemhan "retocadillo" version 2 */
  891. void Bresen(unsigned short x1, unsigned short y1, unsigned short x2,
  892.             unsigned short y2, unsigned short dim)
  893. {
  894.   int dx, dy, sx, sy;
  895.   int count;
  896.   int brc;
  897.   unsigned short inter;
  898.   
  899. /* el bloque de lineas que sigue existe para asegurar que la pendiente
  900.    aproximada de la linea sea siempre la misma (prueben a quitarlas */
  901.   if (y1>y2)
  902.    {
  903.    inter=y1;
  904.    y1=y2;
  905.    y2=inter;
  906.    inter=x1;
  907.    x1=x2;
  908.    x2=inter;
  909.    }
  910.  
  911.   sx = sy = 1;
  912.   dx = x2 - x1;
  913.   dy = y2 - y1;
  914.   if (dx < 0)
  915.   {
  916.     dx *= -1;
  917.     sx *= -1;
  918.   }
  919.   if (dy < 0)
  920.   {
  921.     dy *= -1;
  922.     sy *= -1;
  923.   }
  924.  
  925.   if (dx > dy)
  926.   {
  927.    brc = dx>>1;
  928.     tfil[y1+dim]=x1; 
  929.     for (count = dx; count; count--)
  930.      {
  931.      x1 += sx;
  932.      brc += dy;
  933.      if (brc > dx)
  934.       {
  935.       brc -= dx;
  936.       y1 += sy;
  937.       tfil[y1+dim]=x1;
  938.       }
  939.      }
  940.   }
  941.   else
  942.   {
  943.     brc = dy>>1; 
  944.     tfil[y1+dim]=x1; 
  945.     for (count = dy; count; count--)
  946.     {
  947.       y1 += sy;
  948.       brc += dx;
  949.       if (brc > 0)
  950.       {
  951.         brc -= dy;
  952.         x1 += sx;
  953.       }
  954.     tfil[y1+dim]=x1;
  955.     }
  956.   }
  957. }
  958.  
  959.  
  960.  
  961. void interpolateY(unsigned short y, unsigned char col, unsigned short y1,
  962.               unsigned char col1, unsigned short dim)
  963. {
  964. unsigned short inter;
  965. unsigned char icol;
  966. short a,c;
  967. unsigned short overf;
  968. float calc;
  969.  
  970. /* primero ponemos los colores en los picos de las bandas */
  971. tfilc[y+dim]=col;
  972. tfilc[y1+dim]=col1;
  973. /* ahora procedemos a interpolar */
  974. if (y1>=y)
  975.  {
  976.  if (y1-y==0)
  977.   overf=1;
  978.  else
  979.   overf=y1-y;
  980.  calc=(col1-col)/(overf);
  981.  for (a=0,c=col;a<(y1-y)+1;a++)
  982.   {
  983.   tfilc[(y+a)+dim]=c;
  984.   c+=calc;
  985.   }
  986.  }
  987. else
  988.  {
  989.  if (y-y1==0)
  990.   overf=1;
  991.  else
  992.   overf=y-y1;
  993.  calc=(col-col1)/(overf);
  994.  for (a=0,c=col1;a<(y-y1)+1;a++)
  995.   {
  996.   tfilc[(y1+a)+dim]=c;
  997.   c+=calc;
  998.   }
  999.  }
  1000.  
  1001. }
  1002.  
  1003. /* interpolación de color entre las bandas */
  1004. void interpolateX(unsigned short ymen, unsigned short ymax)
  1005. {
  1006. short a,x,y,calc,c;
  1007.  
  1008. for (a=0,y=ymen;a<(ymax-ymen)+1;a++,y++)
  1009.  {
  1010.  if (tfil[y+480]-tfil[y]==0)
  1011.   {
  1012.   GrPlot(tfil[y],y,tfilc[y]);
  1013.   }
  1014.  else
  1015.   {
  1016.   calc=(tfilc[y+480]-tfilc[y])/(tfil[y+480]-tfil[y]);
  1017.   for (x=tfil[y],c=tfilc[y];x<tfil[y+480];x++)
  1018.    {
  1019.    GrPlot(x,y,c);
  1020.    c+=calc;
  1021.    }
  1022.   } 
  1023.  }
  1024. }
  1025.  
  1026.  
  1027.